home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / containers / utilityClasses / Flex.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  12.3 KB  |  376 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import mx.core.Container;
  4.    import mx.core.FlexVersion;
  5.    import mx.core.IUIComponent;
  6.    import mx.core.mx_internal;
  7.    
  8.    use namespace mx_internal;
  9.    
  10.    public class Flex
  11.    {
  12.       mx_internal static const VERSION:String = "3.0.0.0";
  13.       
  14.       public function Flex()
  15.       {
  16.          super();
  17.       }
  18.       
  19.       public static function flexChildWidthsProportionally(param1:Container, param2:Number, param3:Number) : Number
  20.       {
  21.          var _loc6_:Array = null;
  22.          var _loc7_:FlexChildInfo = null;
  23.          var _loc8_:IUIComponent = null;
  24.          var _loc9_:int = 0;
  25.          var _loc11_:Number = NaN;
  26.          var _loc12_:Number = NaN;
  27.          var _loc13_:Number = NaN;
  28.          var _loc14_:Number = NaN;
  29.          var _loc4_:Number = param2;
  30.          var _loc5_:Number = 0;
  31.          _loc6_ = [];
  32.          var _loc10_:int = param1.numChildren;
  33.          _loc9_ = 0;
  34.          while(_loc9_ < _loc10_)
  35.          {
  36.             _loc8_ = IUIComponent(param1.getChildAt(_loc9_));
  37.             _loc11_ = Number(_loc8_.percentWidth);
  38.             _loc12_ = Number(_loc8_.percentHeight);
  39.             if(!isNaN(_loc12_) && Boolean(_loc8_.includeInLayout))
  40.             {
  41.                _loc13_ = Math.max(_loc8_.minHeight,Math.min(_loc8_.maxHeight,_loc12_ >= 100 ? param3 : param3 * _loc12_ / 100));
  42.             }
  43.             else
  44.             {
  45.                _loc13_ = Number(_loc8_.getExplicitOrMeasuredHeight());
  46.             }
  47.             if(!isNaN(_loc11_) && Boolean(_loc8_.includeInLayout))
  48.             {
  49.                _loc5_ += _loc11_;
  50.                _loc7_ = new FlexChildInfo();
  51.                _loc7_.percent = _loc11_;
  52.                _loc7_.min = _loc8_.minWidth;
  53.                _loc7_.max = _loc8_.maxWidth;
  54.                _loc7_.height = _loc13_;
  55.                _loc7_.child = _loc8_;
  56.                _loc6_.push(_loc7_);
  57.             }
  58.             else
  59.             {
  60.                _loc14_ = Number(_loc8_.getExplicitOrMeasuredWidth());
  61.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  62.                {
  63.                   _loc8_.setActualSize(Math.floor(_loc14_),Math.floor(_loc13_));
  64.                }
  65.                else
  66.                {
  67.                   _loc8_.setActualSize(_loc14_,_loc13_);
  68.                }
  69.                if(_loc8_.includeInLayout)
  70.                {
  71.                   _loc4_ -= _loc8_.width;
  72.                }
  73.             }
  74.             _loc9_++;
  75.          }
  76.          if(_loc5_)
  77.          {
  78.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  79.             _loc10_ = int(_loc6_.length);
  80.             _loc9_ = 0;
  81.             while(_loc9_ < _loc10_)
  82.             {
  83.                _loc7_ = _loc6_[_loc9_];
  84.                _loc8_ = _loc7_.child;
  85.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  86.                {
  87.                   _loc8_.setActualSize(Math.floor(_loc7_.size),Math.floor(_loc7_.height));
  88.                }
  89.                else
  90.                {
  91.                   _loc8_.setActualSize(_loc7_.size,_loc7_.height);
  92.                }
  93.                _loc9_++;
  94.             }
  95.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  96.             {
  97.                distributeExtraWidth(param1,param2);
  98.             }
  99.          }
  100.          return _loc4_;
  101.       }
  102.       
  103.       public static function distributeExtraHeight(param1:Container, param2:Number) : void
  104.       {
  105.          var _loc5_:int = 0;
  106.          var _loc6_:Number = NaN;
  107.          var _loc9_:IUIComponent = null;
  108.          var _loc10_:Number = NaN;
  109.          var _loc11_:Number = NaN;
  110.          var _loc3_:int = param1.numChildren;
  111.          var _loc4_:Boolean = false;
  112.          var _loc7_:Number = param2;
  113.          var _loc8_:Number = 0;
  114.          _loc5_ = 0;
  115.          while(_loc5_ < _loc3_)
  116.          {
  117.             _loc9_ = IUIComponent(param1.getChildAt(_loc5_));
  118.             if(_loc9_.includeInLayout)
  119.             {
  120.                _loc10_ = Number(_loc9_.height);
  121.                _loc6_ = Number(_loc9_.percentHeight);
  122.                _loc8_ += _loc10_;
  123.                if(!isNaN(_loc6_))
  124.                {
  125.                   _loc11_ = Math.ceil(_loc6_ / 100 * param2);
  126.                   if(_loc11_ > _loc10_)
  127.                   {
  128.                      _loc4_ = true;
  129.                   }
  130.                }
  131.             }
  132.             _loc5_++;
  133.          }
  134.          if(!_loc4_)
  135.          {
  136.             return;
  137.          }
  138.          _loc7_ -= _loc8_;
  139.          var _loc12_:Boolean = true;
  140.          while(_loc12_ && _loc7_ > 0)
  141.          {
  142.             _loc12_ = false;
  143.             _loc5_ = 0;
  144.             while(_loc5_ < _loc3_)
  145.             {
  146.                _loc9_ = IUIComponent(param1.getChildAt(_loc5_));
  147.                _loc10_ = Number(_loc9_.height);
  148.                _loc6_ = Number(_loc9_.percentHeight);
  149.                if(!isNaN(_loc6_) && Boolean(_loc9_.includeInLayout) && _loc10_ < _loc9_.maxHeight)
  150.                {
  151.                   _loc11_ = Math.ceil(_loc6_ / 100 * param2);
  152.                   if(_loc11_ > _loc10_)
  153.                   {
  154.                      _loc9_.setActualSize(_loc9_.width,_loc10_ + 1);
  155.                      _loc7_--;
  156.                      _loc12_ = true;
  157.                      if(_loc7_ == 0)
  158.                      {
  159.                         return;
  160.                      }
  161.                   }
  162.                }
  163.                _loc5_++;
  164.             }
  165.          }
  166.       }
  167.       
  168.       public static function distributeExtraWidth(param1:Container, param2:Number) : void
  169.       {
  170.          var _loc5_:int = 0;
  171.          var _loc6_:Number = NaN;
  172.          var _loc9_:IUIComponent = null;
  173.          var _loc10_:Number = NaN;
  174.          var _loc11_:Number = NaN;
  175.          var _loc3_:int = param1.numChildren;
  176.          var _loc4_:Boolean = false;
  177.          var _loc7_:Number = param2;
  178.          var _loc8_:Number = 0;
  179.          _loc5_ = 0;
  180.          while(_loc5_ < _loc3_)
  181.          {
  182.             _loc9_ = IUIComponent(param1.getChildAt(_loc5_));
  183.             if(_loc9_.includeInLayout)
  184.             {
  185.                _loc10_ = Number(_loc9_.width);
  186.                _loc6_ = Number(_loc9_.percentWidth);
  187.                _loc8_ += _loc10_;
  188.                if(!isNaN(_loc6_))
  189.                {
  190.                   _loc11_ = Math.ceil(_loc6_ / 100 * param2);
  191.                   if(_loc11_ > _loc10_)
  192.                   {
  193.                      _loc4_ = true;
  194.                   }
  195.                }
  196.             }
  197.             _loc5_++;
  198.          }
  199.          if(!_loc4_)
  200.          {
  201.             return;
  202.          }
  203.          _loc7_ -= _loc8_;
  204.          var _loc12_:Boolean = true;
  205.          while(_loc12_ && _loc7_ > 0)
  206.          {
  207.             _loc12_ = false;
  208.             _loc5_ = 0;
  209.             while(_loc5_ < _loc3_)
  210.             {
  211.                _loc9_ = IUIComponent(param1.getChildAt(_loc5_));
  212.                _loc10_ = Number(_loc9_.width);
  213.                _loc6_ = Number(_loc9_.percentWidth);
  214.                if(!isNaN(_loc6_) && Boolean(_loc9_.includeInLayout) && _loc10_ < _loc9_.maxWidth)
  215.                {
  216.                   _loc11_ = Math.ceil(_loc6_ / 100 * param2);
  217.                   if(_loc11_ > _loc10_)
  218.                   {
  219.                      _loc9_.setActualSize(_loc10_ + 1,_loc9_.height);
  220.                      _loc7_--;
  221.                      _loc12_ = true;
  222.                      if(_loc7_ == 0)
  223.                      {
  224.                         return;
  225.                      }
  226.                   }
  227.                }
  228.                _loc5_++;
  229.             }
  230.          }
  231.       }
  232.       
  233.       public static function flexChildrenProportionally(param1:Number, param2:Number, param3:Number, param4:Array) : Number
  234.       {
  235.          var _loc6_:Number = NaN;
  236.          var _loc7_:Boolean = false;
  237.          var _loc9_:* = undefined;
  238.          var _loc10_:* = undefined;
  239.          var _loc11_:* = undefined;
  240.          var _loc12_:* = undefined;
  241.          var _loc13_:* = undefined;
  242.          var _loc14_:* = undefined;
  243.          var _loc5_:int = int(param4.length);
  244.          var _loc8_:Number = param2 - param1 * param3 / 100;
  245.          if(_loc8_ > 0)
  246.          {
  247.             param2 -= _loc8_;
  248.          }
  249.          do
  250.          {
  251.             _loc6_ = 0;
  252.             _loc7_ = true;
  253.             _loc9_ = param2 / param3;
  254.             _loc10_ = 0;
  255.             while(_loc10_ < _loc5_)
  256.             {
  257.                _loc11_ = param4[_loc10_];
  258.                _loc12_ = _loc11_.percent * _loc9_;
  259.                if(_loc12_ < _loc11_.min)
  260.                {
  261.                   _loc13_ = _loc11_.min;
  262.                   _loc11_.size = _loc13_;
  263.                   param4[_loc10_] = param4[--_loc5_];
  264.                   param4[_loc5_] = _loc11_;
  265.                   param3 -= _loc11_.percent;
  266.                   param2 -= _loc13_;
  267.                   _loc7_ = false;
  268.                   break;
  269.                }
  270.                if(_loc12_ > _loc11_.max)
  271.                {
  272.                   _loc14_ = _loc11_.max;
  273.                   _loc11_.size = _loc14_;
  274.                   param4[_loc10_] = param4[--_loc5_];
  275.                   param4[_loc5_] = _loc11_;
  276.                   param3 -= _loc11_.percent;
  277.                   param2 -= _loc14_;
  278.                   _loc7_ = false;
  279.                   break;
  280.                }
  281.                _loc11_.size = _loc12_;
  282.                _loc6_ += _loc12_;
  283.                _loc10_++;
  284.             }
  285.          }
  286.          while(!_loc7_);
  287.          
  288.          return Math.max(0,Math.floor(param2 - _loc6_));
  289.       }
  290.       
  291.       public static function flexChildHeightsProportionally(param1:Container, param2:Number, param3:Number) : Number
  292.       {
  293.          var _loc7_:FlexChildInfo = null;
  294.          var _loc8_:IUIComponent = null;
  295.          var _loc9_:int = 0;
  296.          var _loc11_:Number = NaN;
  297.          var _loc12_:Number = NaN;
  298.          var _loc13_:Number = NaN;
  299.          var _loc14_:Number = NaN;
  300.          var _loc4_:Number = param2;
  301.          var _loc5_:Number = 0;
  302.          var _loc6_:Array = [];
  303.          var _loc10_:int = param1.numChildren;
  304.          _loc9_ = 0;
  305.          while(_loc9_ < _loc10_)
  306.          {
  307.             _loc8_ = IUIComponent(param1.getChildAt(_loc9_));
  308.             _loc11_ = Number(_loc8_.percentWidth);
  309.             _loc12_ = Number(_loc8_.percentHeight);
  310.             if(!isNaN(_loc11_) && Boolean(_loc8_.includeInLayout))
  311.             {
  312.                _loc13_ = Math.max(_loc8_.minWidth,Math.min(_loc8_.maxWidth,_loc11_ >= 100 ? param3 : param3 * _loc11_ / 100));
  313.             }
  314.             else
  315.             {
  316.                _loc13_ = Number(_loc8_.getExplicitOrMeasuredWidth());
  317.             }
  318.             if(!isNaN(_loc12_) && Boolean(_loc8_.includeInLayout))
  319.             {
  320.                _loc5_ += _loc12_;
  321.                _loc7_ = new FlexChildInfo();
  322.                _loc7_.percent = _loc12_;
  323.                _loc7_.min = _loc8_.minHeight;
  324.                _loc7_.max = _loc8_.maxHeight;
  325.                _loc7_.width = _loc13_;
  326.                _loc7_.child = _loc8_;
  327.                _loc6_.push(_loc7_);
  328.             }
  329.             else
  330.             {
  331.                _loc14_ = Number(_loc8_.getExplicitOrMeasuredHeight());
  332.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  333.                {
  334.                   _loc8_.setActualSize(Math.floor(_loc13_),Math.floor(_loc14_));
  335.                }
  336.                else
  337.                {
  338.                   _loc8_.setActualSize(_loc13_,_loc14_);
  339.                }
  340.                if(_loc8_.includeInLayout)
  341.                {
  342.                   _loc4_ -= _loc8_.height;
  343.                }
  344.             }
  345.             _loc9_++;
  346.          }
  347.          if(_loc5_)
  348.          {
  349.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  350.             _loc10_ = int(_loc6_.length);
  351.             _loc9_ = 0;
  352.             while(_loc9_ < _loc10_)
  353.             {
  354.                _loc7_ = _loc6_[_loc9_];
  355.                _loc8_ = _loc7_.child;
  356.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  357.                {
  358.                   _loc8_.setActualSize(Math.floor(_loc7_.width),Math.floor(_loc7_.size));
  359.                }
  360.                else
  361.                {
  362.                   _loc8_.setActualSize(_loc7_.width,_loc7_.size);
  363.                }
  364.                _loc9_++;
  365.             }
  366.             if(FlexVersion.compatibilityVersion >= FlexVersion.VERSION_3_0)
  367.             {
  368.                distributeExtraHeight(param1,param2);
  369.             }
  370.          }
  371.          return _loc4_;
  372.       }
  373.    }
  374. }
  375.  
  376.